Unang Hakbang sa Quantum Computing

Difficulties: Beginner
QPU time usage: 11s

Maligayang pagdating, mga hacker! Tuwang-tuwa kaming makasama ka sa workshop. Ang pangunahing layunin ng panimulang hands-on na ito ay ihanda ka sa iyong quantum journey sa pamamagitan ng 1) paggabay kung paano i-install ang qiskit 2) paano gumawa ng IBM Cloud account at maghanda ng api_key at crn upang gumamit ng tunay na quantum computer at 3) gumawa ng iyong unang quantum circuit, 4) lutasin ang isang quantum state quiz at 5) Patakbuhin ang iyong mga circuit sa tunay na quantum computer at i-plot ang resulta.

1. Una sa lahat: Qiskit

Ano ang Qiskit

Ang Qiskit SDK ay isang high performance software stack na ginawa upang tulungan ang mga developer at researcher na samantalahin ang buong kapangyarihan ng quantum computers sa utility scale at higit pa. Sa core nito ay ang Qiskit SDK, isang open source software development kit para sa pagtatrabaho sa quantum computers sa antas ng pinalawak na quantum circuits. Operators at primitives. Pinapahintulutan ng Qiskit SDK ang sinuman na makakuha ng optimal performance mula sa tunay na quantum computers gamit ang kanilang ginustong computing environment.

Higit pa sa SDK, kasama rin sa Qiskit ang isang suite ng high performance tools at services tulad ng Qiskit Runtime Service, na nagbibigay-daan sa optimized computations sa IBM quantum computers sa pamamagitan ng cloud gamit ang primitives na namamahala sa error mitigation. Ang Qiskit Transpiler service, na nagbibigay ng state of the art heuristic at AI powered methods na nagpapabuti sa performance para sa karaniwang mga quantum circuit optimization tasks.

Ang Qiskit functions, isang catalog ng IBM at third party services na nagpapadali sa pag-optimize ng workloads at paggamit ng Qiskit para sa industry use cases. Kung ikaw ay quantum software developer, quantum experimentalist, computational scientist, o naghahanap lang upang magsimula, ang modular at flexible framework ng Qiskit ay nagpapahintulot sa iyong magtrabaho sa abstraction level na pinakaangkop sa iyong mga pangangailangan.

Ang Qiskit ay idinisenyo para sa extensibility at customization, kaya maaari kang kumuha ng industry leading performance at humawak ng mga bagong uri ng problema. Ang isang high performance code base ay nangangahulugang ang Qiskit SDK ay gumagana nang mas mabilis, gumagamit ng mas kaunting memory, at naghahatid ng mas mahusay na resulta kaysa dati. At ipinapakilala ka rin ng Qiskit sa isang malaking komunidad ng mga user at developer na sabik na tanggapin ka at tumulong na sagutin ang iyong mga tanong. Unang inilunsad noong 2019, ang Qiskit advocate program ay isang global, community-centered initiative na nag-rerecruit ng mga quantum computing professionals at enthusiasts mula sa buong mundo. Sa paglipas ng mga taon, naging kinikilalang mga lider ang mga advocate sa quantum community. Gusto mo bang maging susunod na quantum leader? Huwag mag-atubiling mag-apply - dito

I-install ang Qiskit

Una, suriin na ang bersyon ng Python na ginagamit mo sa iyong environment ay python>=3.10, upang matiyak na ito ay compatible sa pinakabagong Qiskit version na gagamitin natin

from platform import python_version

print(python_version())

Kung hindi, puwede mo itong i-upgrade gamit ang tool na gusto mo. Kung hindi ka sigurado kung paano, narito ang ilang mungkahi:

MacOS: Homebrew
Linux: sudo apt-get update

May detalyadong gabay kung paano i-upgrade ang Python depende sa iyong OS dito: How to update Python

Para sa karagdagang impormasyon, tingnan ang QGSS (Qiskit Global Summer School) 2025 wiki: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Maaari mong i-verify ang iyong installation sa pamamagitan ng pagpapatakbo ng cell sa ibaba. Kung tama ang installation, ibabalik nito ang qiskit version.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Troubleshooting

Kung nagka-error ang nakaraang cell, puwede kang mag-install ng Qiskit sa loob ng virtual environment (dalawang pamamaraan ang iminumungkahi sa ibaba). Kung walang error, laktawan mo na lang ang cell na ito at magpatuloy sa susunod.

Dito ay dalawang paraan para mag-set up ng virtual environment para i-install ang Qiskit.

Gamit ang venv, tulad ng nakapaliwanag sa Qiskit installation guide.
Gamit ang conda, tulad ng ipinakita sa video na ito ng Coding with Qiskit.

2. I-set up ang iyong IBM Cloud account

Para gumamit ng tunay na quantum computer, kailangan mo ng api key — ang pangunahing ticket mo para makapasok sa cloud — at ng crn — isang token na magbibigay sa iyo ng access sa iyong mga resources sa pamamagitan ng iyong account.

I-set up ang iyong account ganito:

Pumunta sa IBM Quantum® Platform.
Pumunta sa kanang sulok sa itaas (tulad ng makikita sa larawan sa itaas), gumawa ng iyong API token, at kopyahin ito sa ligtas na lugar.
Sa susunod na cell, palitan ang deleteThisAndPasteYourAPIKeyHere ng iyong API key.
Pumunta sa kaliwang sulok sa ibaba (tulad ng makikita sa larawan sa itaas) at gumawa ng instance. Siguraduhing piliin ang open plan.
Pagkatapos gawin ang instance, kopyahin ang CRN code nito. Puwede kang mag-refresh para makita ang instance.
Sa cell sa ibaba, palitan ang deleteThisAndPasteYourCRNHere ng iyong CRN code.

Tingnan ang gabay na ito para sa mas detalyadong impormasyon kung paano i-set up ang iyong IBM Cloud® account.

⚠️ Tandaan: Ituring ang iyong API key na parang isang secure na password. Tingnan ang Cloud setup guide para sa karagdagang impormasyon tungkol sa paggamit ng iyong API key sa ligtas at hindi ligtas na mga environment.

Dagdag pa, kung miyembro ka ng IBM partner network university, gamitin ang email address ng iyong institusyon para sa iyong IBM ID upang matanggap ang partner benefit.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Ang unang Quantum Circuit mo

Quantum circuits

Ang pangunahing yunit ng Qiskit ay ang quantum circuit, na isang serye ng mga instruksyon na magagamit ng quantum computer para magtrabaho sa quantum bits ng impormasyon, kilala rin bilang qubits. Ang mga qubit na ito ay may espesyal na katangian na nagbibigay-daan sa mga quantum computer na harapin ang mga problema nang naiiba kaysa sa iyong laptop o iPhone. Mabilis na sumusulong ang Qiskit bilang teknolohiya — maaari ka pa ring manu-manong mag-disenyo ng iyong mga quantum circuit at magpasya kung paano ito patakbuhin (at maraming magagandang dahilan para gawin ito), ngunit nagbibigay rin ang IBM Quantum ng mga tool na nagpapasimple ng proseso. Para sa layunin ng pagkatuto, magdidisenyo tayo ng isang simpleng circuit at ipapatakbo ito sa isang simulator.

Mabilis lang nating tataklawin ang overview na ito dahil, totoo naman, maraming oras ang maaaring gumastos sa pagsasalamin ng mga basics ng quantum information at computation. Sa katunayan, nagawa na ito ng IBM Quantum sa pamamagitan ng isang written course at isang serye ng video lectures na nakatuon sa paksa. Kung kailangan mo ng refresher, tingnan mo sila!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Mga Pangunahing Operasyon sa Qubits at Measurements

Pagsusulat ng mga single-qubit states

Simulan nating tingnan ang isang single qubit. Ang pangunahing pagkakaiba ng classical bit, na puwedeng kumuha ng halaga na 0 at 1 lamang, ay ang quantum bit, o qubit, ay maaaring nasa mga state na $\vert0\rangle$ , $\vert1\rangle$ , pati na rin ang isang linear combination ng dalawang state na ito. Ang katangiang ito ay kilala bilang superposition, at nagbibigay-daan sa atin na isulat ang pinaka-pangkalahatang state ng isang qubit bilang:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Kung susukatin natin ang state ng qubit na ito, mahahanap natin ang resulta na $1$ na may posibilidad na $p$ , at ang resulta na $0$ na may posibilidad na $1-p$ . Tulad ng makikita mo, ang kabuuang posibilidad ay $1$ , ibig sabihin palagi nating mahahanap ang $0$ o $1$ — walang ibang posibleng resulta.

Bukod sa $p$ , puwede mong napansin ang isa pang parameter sa itaas. Ang variable na $\phi$ ay nagpapakita ng relative quantum phase sa pagitan ng dalawang state na $\vert0\rangle$ at $\vert1\rangle$ . Tulad ng matutuklasan natin sa paglaon, ang relative phase na ito ay napakahalaga. Sa ngayon, sapat na itong malaman: ang quantum phase ang nagbibigay-daan sa interference sa pagitan ng mga quantum state, na nagpapahintulot sa atin na magsulat ng mga quantum algorithm para sa paglutas ng mga partikular na gawain.

Pag-visualize ng mga quantum state

Sa buong ehersisyong ito, ginagamit natin ang tinatawag na qsphere para ma-visualize ang mga quantum state. Ganito ang hitsura ng qsphere para sa mga state na $\vert0\rangle$ at $\vert1\rangle$ . Pansinin na ang pinakamataas na bahagi ng sphere ay kumakatawan sa state na $\vert0\rangle$ , habang ang ibaba ay kumakatawan sa $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Maaari kang gumawa ng parehong QSphere gamit ang isang quantum circuit. Ang statevector na ginagamit dito ay mula sa $|0\rangle$ state. Sa Qiskit, ang qubit ay ini-initialize sa $|0\rangle$ state. Subukang patakbuhin ang circuit sa ibaba at tingnan kung makukuha mo ang parehong QSphere.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Ngayon ibisualisa naman natin ang $|1\rangle$ na estado. Hindi na dapat nakakagulat na ang superposition state na may quantum phase na $\phi = 0$ at posibilidad na $p = 1/2$ (ibig sabihin, pantay na pagkakataon ng pagsukat ng 0 at 1) ay ipinapakita sa qsphere na may dalawang punto. Gayunpaman, pansinin din na ang laki ng mga bilog sa dalawang punto ay mas maliit kaysa nang mayroon lang tayong $\vert0\rangle$ at $\vert1\rangle$ sa itaas. Ito ay dahil ang laki ng mga bilog ay proporsyonal sa posibilidad ng pagsukat ng bawat isa, na ngayon ay nabawasan ng kalahati.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Sa kaso ng mga superposition state kung saan ang quantum phase ay hindi zero, ang qsphere ay nagbibigay-daan sa atin na ma-visualize ang phase na iyon sa pamamagitan ng pagbabago ng kulay ng kaukulang blob. Halimbawa, ang state na may $\phi = 90^\circ$ (degrees) at posibilidad na $p = 1/2$ ay ipinapakita sa qsphere sa ibaba.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Pag-manipulate ng mga qubit

Ang mga qubit ay nima-manipulate sa pamamagitan ng pag-apply ng mga quantum gate. Balikan natin ang overview ng iba't ibang gate na titingnan natin sa mga susunod na ehersisyo.

Una, ilarawan natin kung paano natin mababago ang halaga ng $p$ para sa ating pangkalahatang quantum state. Para gawin ito, gagamit tayo ng dalawang gate:

$X$ -gate: Ang gate na ito ay nagpapalit-palit sa pagitan ng dalawang state na $\vert0\rangle$ at $\vert1\rangle$ . Ang operasyong ito ay katulad ng klasikal na NOT gate. Dahil dito, ang $X$ -gate ay minsan tinatawag na bit flip o NOT gate. Sa matematika, binabago ng $X$ gate ang $p$ sa $1-p$ , kaya lalo na mula 0 papuntang 1, at kabaligtaran.
$H$ -gate: Ang gate na ito ay nagbibigay-daan sa atin na lumipat mula sa state na $\vert0\rangle$ papunta sa state na $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Ang state na ito ay kilala rin bilang $\vert+\rangle$ . Sa matematika, ibig sabihin nito ang paglipat mula sa $p=0, \phi=0$ papunta sa $p=1/2, \phi=0$ . Dahil ang panghuling state ng qubit ay isang superposition ng $\vert0\rangle$ at $\vert1\rangle$ , ang Hadamard gate ay kumakatawan sa isang tunay na quantum operation.

Pansinin na parehong nagbago ang halaga ng $p$ ng dalawang gate, ngunit hindi ang $\phi$ . Sa kabutihang palad, medyo madali lang na ma-visualize ang aksyon ng mga gate na ito sa pamamagitan ng pagtingin sa pigura sa ibaba.

Kapag nasa state na tayo ng $\vert+\rangle$ , maaari na tayong baguhin ang quantum phase sa pamamagitan ng pag-apply ng iba pang mga gate. Halimbawa, ang $S$ gate ay nagdadagdag ng phase na $90$ degrees sa $\phi$ , habang ang $Z$ gate ay nagdadagdag ng phase na $180$ degrees sa $\phi$ . Para ibawas ang phase na $90$ degrees, maaari tayong mag-apply ng $S^\dagger$ gate, na binabasa bilang S-dagger at karaniwang isinusulat bilang sdg. Sa wakas, mayroon ding $Y$ gate na nag-a-apply ng sunud-sunod na $Z$ at $X$ gate.

Maaari kang mag-eksperimento sa mga gate na $X$ , $Y$ , $Z$ , $H$ , $S$ at $S^\dagger$ para masanay sa iba't ibang operasyon at kung paano nila naaapektuhan ang state ng isang qubit. Magagawa mo ito sa pamamagitan ng pagbisita sa Circuit Composer at pagsisimula ng aming circuit widget. Pagkatapos bisitahin ang circuit composer, pumili ng gate na ila-apply sa isang qubit, at pagkatapos ay piliin ang qubit (sa mga unang halimbawa, ang tanging qubit na mapipili ay qubit 0). Panoorin kung paano nagbabago ang kaukulang state sa bawat gate, kasama ang paglalarawan ng state na iyon. Magbibigay din ito sa iyo ng code na gumagawa ng kaukulang quantum circuit sa Qiskit.

Kung gusto mong matuto pa tungkol sa paglalarawan ng mga quantum state, Pauli operators, at iba pang single-qubit gate, tingnan ang Quantum Information ng Single System sa Basics of Quantum Information Course ni John Watrous.

Mga Pagsasanay: Quantum Circuits Gamit ang Single-Qubit Gates

Mayroon ditong apat na maliit na pagsasanay para maabot ang iba't ibang state sa qsphere. Maaari mong lutasin ang mga ito gamit ang circuit composer at i-copy-paste ang code nito sa kaukulang mga cell para gumawa ng mga quantum circuit, o direkta kang makakapaglagay ng kombinasyon ng mga sumusunod na linya ng code sa programa para i-apply ang iba't ibang gate:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

Ang '(0)' ay nagpapakita na ina-apply natin ang gate na ito sa qubit na 'q0', na siyang una (at sa kasong ito ang tanging) qubit.

Subukang makamit ang ibinigay na state sa qsphere sa bawat isa sa mga sumusunod na ehersisyo.

i) Magsimula tayo sa pamamagitan ng pagsasagawa ng bit flip. Ang layunin ay maabot ang state na $\vert1\rangle$ simula sa state na $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Susunod, gumawa tayo ng superposition. Ang layunin ay maabot ang state na $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Pagsamahin natin ang dalawa. Ang layunin ay maabot ang state na $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Kaya mo bang pagsamahin ang dalawang nakaraang gawain para makuha ang solusyon?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Sa wakas, lumipat tayo sa mga complex number. Ang layunin ay maabot ang state na $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quantum Quiz na may Multi-Qubit Gates

Mahusay! Ngayon na naiintindihan mo na ang mga single-qubit gate, tingnan natin ang mga gate na nagpapatakbo sa maramihang qubit. Dito ay hihilingin sa iyo na lutasin ang 4 quantum state quizzes sa pamamagitan ng pagsasama ng mga single-qubit gate at multi-qubit gate. Ang mga pangunahing gate sa dalawang qubit ay ang mga sumusunod:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Kung gusto mong matuto pa tungkol sa iba't ibang multi-qubit gate at ang kanilang mga relasyon, bisitahin ang Quantum Information ng multiple systems, mula sa Basics of Quantum Information Course ni John.

Pansinin na para sa dalawang qubit, ang pangkalahatang state ay nasa anyo na $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , kung saan ang $a$ , $b$ , $c$ , at $d$ ay mga complex number na ang squared na absolute values ay nagbibigay ng posibilidad ng pagsukat ng kaukulang state; halimbawa, ang $|a|^2$ ay ang posibilidad na matapos sa state na '0' sa parehong qubit. Ibig sabihin nito, maaari na tayong magkaroon ng hanggang apat na punto sa qsphere.

Sisimulan natin sa canonical na two-qubit gate, ang controlled-NOT (kilala rin bilang CNOT o CX) gate. Dito, tulad ng lahat ng controlled two-qubit gate, ang isang qubit ay tinutukoy bilang "control", habang ang isa ay tinatawag na "target". Kung ang control qubit ay nasa state na $|0\rangle$ , inilalapat nito ang identity $I$ gate sa target, ibig sabihin walang operasyong ginagawa. Sa kabilang banda, kung ang control qubit ay nasa state na $|1\rangle$ , isang X-gate ang isinasagawa sa target qubit. Kaya naman, kapag ang parehong qubit ay nasa isa sa dalawang klasikal na state, $|0\rangle$ o $|1\rangle$ , ang CNOT gate ay limitado sa mga klasikal na operasyon.

Ang sitwasyong ito ay dramatikong nagbabago kapag una nating ina-apply ang Hadamard gate sa control qubit, na inilalagay ito sa superposition state na $|+\rangle$ . Ang aksyon ng CNOT gate sa hindi klasikal na input na ito ay maaaring makagawa ng mga lubhang entangled na state sa pagitan ng control at target qubit. Kung ang target qubit ay nasa $|0\rangle$ state sa simula, ang nagresultang state ay tinutukoy ng $|\Phi^+\rangle$ , at isa ito sa tinatawag na Bell states.

i) Buuin ang Bell state na $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Para sa state na ito, magkakaroon tayo ng posibilidad na $\frac{1}{2}$ sa pagsukat ng "00" at posibilidad na $\frac{1}{2}$ sa pagsukat ng "11". Kaya naman, ang mga resulta ng parehong qubit ay ganap na magkakaugnay.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Susunod, subukang gumawa ng state ng ganap na magkasalungat na qubit. Pansinin ang minus sign dito, na nagpapakita ng relative phase sa pagitan ng dalawang state.

ii) Buuin ang Bell state na $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Ibinibigay sa iyo ang quantum circuit na inilalarawan sa function sa ibaba. I-swap ang mga state ng una at pangalawang qubit para makuha ang QSphere na ito.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Sumulat ng program mula sa simula na lumilikha ng GHZ state (sa tatlong qubit), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Patakbuhin ang iyong circuit at tingnan ang resulta sa tunay na quantum computer

Ngayon na alam na natin kung paano bumuo ng quantum circuit para ma-manipulate ang statevector ng mga qubit. At oras na para sa pinaka-kapana-panabik na bahagi: patakbuhin ito at tingnan ang output! Dito matututunan natin ang modernong at epektibong paraan para patakbuhin ang ating mga circuit gamit ang Qiskit.

Ang Qiskit pattern ay isang pangkalahatang balangkas para sa pagbasag ng mga domain-specific na problema at pag-contextualize ng mga kinakailangang kakayahan sa mga yugto. Nagbibigay-daan ito sa seamless composability ng mga bagong kakayahang binuo ng mga IBM Quantum researcher (at iba pa) at nagbubukas ng kinabukasan kung saan ang mga quantum computing task ay isinasagawa ng makapangyarihang heterogeneous (CPU/GPU/QPU) na computing infrastructure.

Ang apat na hakbang ng Qiskit pattern ay ang mga sumusunod:

Map ang problema sa mga quantum circuit at operator
Optimize para sa target hardware
Execute sa target hardware
Post-process ng mga resulta

Natapos na natin ang Step 1: Mapping, sa pamamagitan ng pagbuo ng mga quantum circuit para makamit ang nais na quantum state. Ngayon, sabay nating talakayin ang mga natitirang hakbang para makita ang mga resulta.

Optimize

Dito itatakda natin ang backend para patakbuhin ang mga circuit — maaari kang pumili ng least busy qpu mula sa iyong mga naa-access na qpu group, o simpleng pumili ng simulator kung kulang na ang iyong natitirang GPU time. Kapag napili na ang backend, ita-transpile ng pass_manager ang iyong mga circuit sa native gate set ng backend na pinili mo at io-optimize ito para makakuha ng mas magandang resulta. Madali mong maide-declare ang pass_manager gamit ang generate_preset_pass_manager at ang setting ng optimization_level — mas mataas ang numero, mas maraming optimization steps.

Kapana-panabik ang susunod na hakbang — ipapatakbo na natin ang quantum circuit gamit ang Qiskit Runtime!

Gagawin natin ito gamit ang dalawang Qiskit primitives:

Sampler — nag-sa-sample ng output register mula sa execution ng isa o higit pang quantum circuit. Ang output nito ay mga counts sa bawat per-shot measurement.
Estimator — kinokompute ang expectation value ng isa o higit pang observable na may kaugnayan sa mga state na nabuo ng quantum circuit. Ang output nito ay binubuo ng mga expectation value kasama ang kanilang mga standard error.

Dito, gagamitin natin ang Sampler para patakbuhin ang ating mga circuit. Ipinapakita ng code cell sa ibaba kung paano ka unang mag-define ng backend at ng pass manager para dito. Pagkatapos, magdadagdag ito ng measurement sa lahat ng circuit at gagawa ng array ng mga quantum circuit (pub) para ipasa sa Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Execute

Patakbuhin na natin ang ating mga circuit. Kung maraming naghihintay sa queue sa cloud, i-print at i-save ang job_id para sa susunod na paggamit at suriin ang job_status. Kapag nakita mong nagbago na ang job status sa Done, kunin na ang resulta ng job.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-process

Ang huling hakbang ay ang pag-interpret ng visualization para maunawaan ang mga quantum state na ating nilikha. Bago mag-plot ng ilang graph, kunin muna natin ang lahat ng counts mula sa lahat ng circuit. Pagkatapos ay gagawa tayo ng 4 na plot sa pamamagitan ng pag-categorize ng mga circuit.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Ang mga Single Qubit State

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Ang mga Superpositioned One Qubit State

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Mga Two Qubit State

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Mga Three Qubit State

plot_distribution(counts_all[8], legend=['qc9'])

Karagdagang Hamon

Nakakita ka ba ng anumang ingay (noise) sa aktwal na experimental na resulta ng backend? Ang pag-alis ng qubit noise ay isa sa mga aktibong larangan ng pananaliksik. Subukan ang iba't ibang error mitigation at suppression options ng Qiskit Runtime para makita kung paano nagbabago ang ingay sa mga resulta ng execution! (Tandaan) Ang mga opsyong ito ay nangangailangan ng karagdagang QPU time.

Karagdagang Impormasyon

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Una sa lahat: Qiskit​

Ano ang Qiskit​

I-install ang Qiskit​

Troubleshooting​

2. I-set up ang iyong IBM Cloud account ​

3. Ang unang Quantum Circuit mo​

Quantum circuits​

Mga Pangunahing Operasyon sa Qubits at Measurements​

Pagsusulat ng mga single-qubit states​

Pag-visualize ng mga quantum state​

Pag-manipulate ng mga qubit​

Mga Pagsasanay: Quantum Circuits Gamit ang Single-Qubit Gates​

i) Magsimula tayo sa pamamagitan ng pagsasagawa ng bit flip. Ang layunin ay maabot ang state na ∣1⟩\vert1\rangle∣1⟩ simula sa state na ∣0⟩\vert0\rangle∣0⟩.​

ii) Susunod, gumawa tayo ng superposition. Ang layunin ay maabot ang state na ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Pagsamahin natin ang dalawa. Ang layunin ay maabot ang state na ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Sa wakas, lumipat tayo sa mga complex number. Ang layunin ay maabot ang state na ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Quantum Quiz na may Multi-Qubit Gates​

i) Buuin ang Bell state na ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Buuin ang Bell state na ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Ibinibigay sa iyo ang quantum circuit na inilalarawan sa function sa ibaba. I-swap ang mga state ng una at pangalawang qubit para makuha ang QSphere na ito.​

iv) Sumulat ng program mula sa simula na lumilikha ng GHZ state (sa tatlong qubit), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Patakbuhin ang iyong circuit at tingnan ang resulta sa tunay na quantum computer​

Optimize​

Execute​

Post-process​

Karagdagang Hamon​

Karagdagang Impormasyon​